System and method for replication container performance and policy validation using real time network traffic

ABSTRACT

Systems, methods, and computer-readable media are disclosed for using real time network traffic for validating policy configuration(s) of containers, virtual machines, bare-metals, etc. In one aspect of the present disclosure a method includes receiving, at a controller, an incoming data packet destined for one or more containers; replicating, at the controller, the incoming data packet for validating at least one non-production container to yield a replicated data packet; sending the replicated data packet to the at least one non-production container; and dropping any data packet received from the at least one non-production container at a corresponding incoming port of the controller.

The present technology pertains to replication of real time network data traffic for purposes of validation of policies and performances of non-production containers.

BACKGROUND

Use of containers for providing various network service functions are on the rise. Currently any new container is instantiated by the operators on DevOps environment for validation purpose before moving it to a production environment. For example, in a Contiv environment, an operator creates micro segmentation and creates policy to put the new container in non-production environment (testing environment). Once the container is instantiated, operators will try to simulate synthetic traffic to validate the policies and upon a successful validation of the container, move the container to a production environment to be used for providing one or more network service functions to customers, end users, etc. This is an inefficient and resource intensive process of validating containers before putting them into production.

BRIEF DESCRIPTION OF THE DRAWINGS

In order to describe the manner in which the above-recited and other advantages and features of the disclosure can be obtained, a more particular description of the principles briefly described above will be rendered by reference to specific embodiments thereof which are illustrated in the appended drawings. Understanding that these drawings depict only exemplary embodiments of the disclosure and are not therefore to be considered to be limiting of its scope, the principles herein are described and explained with additional specificity and detail through the use of the accompanying drawings in which:

FIGS. 1A-D illustrate example network environments and architectures, according to one aspect of the present disclosure;

FIG. 2 illustrates an example network device suitable for performing switching, routing, load balancing, and other networking operations, according to an aspect of the present disclosure;

FIG. 3 illustrates a computing system architecture, according to an aspect of the present disclosure:

FIG. 4 illustrates an example system of containers providing a service, according to an aspect of the present disclosure;

FIG. 5 describes a method of replicating real time network traffic for validating a container performance, according to an aspect of the present disclosure;

FIG. 6 illustrates a an example service module table, according to one aspect of the present disclosure;

FIG. 7 illustrates an example of the container validation process of FIG. 5, according an aspect of the present disclosure; and

FIG. 8 illustrates an example of the container validation process of FIG. 5, according an aspect of the present disclosure.

DESCRIPTION OF EXAMPLE EMBODIMENTS

Various examples of the disclosure are discussed in detail below. While specific implementations are discussed, it should be understood that this is done for illustration purposes only. A person skilled in the relevant art will recognize that other components and configurations may be used without parting from the spirit and scope of the disclosure.

References to one or an example embodiment in the present disclosure can be, but not necessarily are, references to the same example embodiment; and, such references mean at least one of the example embodiments.

Reference to “one example embodiment” or “an example embodiment” means that a particular feature, structure, or characteristic described in connection with the example embodiment is included in at least one example of the disclosure. The appearances of the phrase “in one example embodiment” in various places in the specification are not necessarily all referring to the same example embodiment, nor are separate or alternative example embodiments mutually exclusive of other example embodiments. Moreover, various features are described which may be exhibited by some example embodiments and not by others. Similarly, various features are described which may be features for some example embodiments but not other example embodiments.

The terms used in this specification generally have their ordinary meanings in the art, within the context of the disclosure, and in the specific context where each term is used. Alternative language and synonyms may be used for any one or more of the terms discussed herein, and no special significance should be placed upon whether or not a term is elaborated or discussed herein. Synonyms for certain terms are provided. A recital of one or more synonyms does not exclude the use of other synonyms. The use of examples anywhere in this specification including examples of any terms discussed herein is illustrative only, and is not intended to further limit the scope and meaning of the disclosure or of any exemplified term. Likewise, the disclosure is not limited to various examples given in this specification.

Without intent to limit the scope of the disclosure, examples of instruments, apparatus, methods and their related results according to examples of the present disclosure are given below. Note that titles or subtitles may be used in the examples for convenience of a reader, which in no way should limit the scope of the disclosure. Unless otherwise defined, technical and scientific terms used herein have the meaning as commonly understood by one of ordinary skill in the art to which this disclosure pertains. In the case of conflict, the present document, including definitions will control.

Although the terms first, second, etc. may be used herein to describe various elements, these elements should not be limited by these terms. These terms are only used to distinguish one element from another. For example, a first element could be termed a second element, and similarly, a second element could be termed a first element, without departing from the scope of this disclosure. As used herein, the term “and/or,” includes any and all combinations of one or more of the associated listed items.

When an element is referred to as being “connected.” or “coupled.” to another element, it can be directly connected or coupled to the other element or intervening elements may be present. By contrast, when an element is referred to as being “directly connected,” or “directly coupled,” to another element, there are no intervening elements present. Other words used to describe the relationship between elements should be interpreted in a like fashion (e.g., “between,” versus “directly between.” “adjacent.” versus “directly adjacent,” etc.).

The terminology used herein is for the purpose of describing particular examples only and is not intended to be limiting. As used herein, the singular forms “a”, “an”, and “the” are intended to include the plural forms as well, unless the context clearly indicates otherwise. It will be further understood that the terms “comprises”. “comprising,”. “includes” and/or “including”, when used herein, specify the presence of stated features, integers, steps, operations, elements, and/or components, but do not preclude the presence or addition of one or more other features, integers, steps, operations, elements, components, and/or groups thereof.

It should also be noted that in some alternative implementations, the functions/acts noted may occur out of the order noted in the figures. For example, two figures shown in succession may in fact be executed substantially concurrently or may sometimes be executed in the reverse order, depending upon the functionality/acts involved.

Specific details are provided in the following description to provide a thorough understanding of examples. However, it will be understood by one of ordinary skill in the art that examples may be practiced without these specific details. For example, systems may be shown in block diagrams so as not to obscure the examples in unnecessary detail. In other instances, well-known processes, structures and techniques may be shown without unnecessary detail in order to avoid obscuring examples.

In the following description, illustrative examples will be described with reference to acts and symbolic representations of operations (e.g., in the form of flow charts, flow diagrams, data flow diagrams, structure diagrams, block diagrams, etc.) that may be implemented as program services or functional processes include routines, programs, objects, components, data structures, etc., that perform particular tasks or implement particular abstract data types and may be implemented using hardware at network elements. Non-limiting examples of such hardware may include one or more Central Processing Units (CPUs), digital signal processors (DSPs), application-specific-integrated-circuits, field programmable gate arrays (FPGAs), computers or the like.

Additional features and advantages of the disclosure will be set forth in the description which follows, and in part will be obvious from the description, or can be learned by practice of the herein disclosed principles. The features and advantages of the disclosure can be realized and obtained by means of the instruments and combinations particularly pointed out in the appended claims. These and other features of the disclosure will become more fully apparent from the following description and appended claims, or can be learned by the practice of the principles set forth herein.

OVERVIEW

In one aspect of the present disclosure, a method includes receiving, at a controller, an incoming data packet destined for one or more containers; replicating, at the controller, the incoming data packet for validating at least one non-production container to yield a replicated data packet; sending the replicated data packet to the at least one non-production container; and dropping any data packet received from the at least one non-production container at a corresponding incoming port of the controller.

In one aspect of the present disclosure, a device includes memory having computer-readable instructions stored therein; and one or more processors configured to execute the computer-readable instructions to receive an incoming data packet destined for one or more containers; replicate the incoming data packet for validating at least one non-production container to yield a replicated data packet; send the replicated data packet to the at least one non-production container; and drop any data packet received from the at least one non-production container at a corresponding incoming port of the controller.

In one aspect of the present disclosure, one or more non-transitory computer-readable mediums have computer-readable instructions stored thereon, which when executed by one or more processors, cause the one or more processors to receive an incoming data packet destined for one or more containers; replicate the incoming data packet for validating at least one non-production container to yield a replicated data packet; send the replicated data packet to the at least one non-production container; and drop any data packet received from the at least one non-production container at a corresponding incoming port of the controller.

DESCRIPTION

The disclosed technology is directed to the use of real time network traffic for validating policy configuration(s) and performance of containers, virtual machines (VM) or bare-metals (in test mode/non-production mode before moving such containers. VMs and/or bare-metals into production for providing a particular service function) without impacting the real time network traffic and/or service functions provided for the real time network traffic.

Examples of the present disclosure leverage the use of Contiv HostAgents to facilitate such non-production container/VM/bare-metal validation using replicated real time network traffic before moving the container/VM/bare-metal into production.

While throughout the disclosure, containers are used as examples, inventive concepts are not limited thereto and are equally applicable to validation of VMs and bare-metals.

The disclosure begins with a description of example network environments and architectures, as illustrated in FIGS. 1A-D.

FIG. 1A illustrates an example system, according to one aspect of the present disclosure. System 100 of FIG. 1A includes a controller 102 and a distributed streaming system 120. Controller 102 can be an application, a software container, a virtual machine, a service chain, a virtual function(s), etc. Controller 102 can run on one or more devices or servers having components such as one or more processors (e.g., processor 104), one or more memories (e.g., memory 106), a transceiver 108, a display device 110 and an input device 112. Processor 104 can be configured to execute computer-readable instructions stored on memory 106 for performing the functionalities which will be described below with reference to FIGS. 4-6. Throughout the disclosure, controller 102 can be referred to as system management component 102, management device 102, device 102 and/or system controller 102.

Transceiver 108 can be any known or to be developed receiver and transmitter through which controller 102 can send and receive information to and from external components such as components of distributed streaming system 120.

Network operators and controllers (operational management component) can use display 110 to view data corresponding to status and/or management of operation of distributed streaming system 120, as will be described below. Display 110 can be any type of know or to be developed display such as a liquid crystal display (LCD), a light emitting diode display (LED), etc.

Input device 112 can be any known or to be developed input device including, but not limited to, a keyboard, a touch-based input device, etc. In one example, display 110 and input device 112 can be the same when display 110 is a touch enabled device capable of receiving inputs. Network managers and operators can provide appropriate commands for monitoring and management of distributed streaming system 120, via input device 112.

Controller 102 can communicate with various components of distributed streaming system 120 via any known or to be developed wireless communications and/or wired communications mean. For example, controller 102 can access and obtain information (and/or send information) to each component of distributed system 120 via a network such as a local area wireless network (LAN), a virtual local area network (vLAN) and/or any other type of, known or to be developed, network through which controller 102 can communicate with each component of distributed streaming system 120.

In one aspect, controller 102 can be any known or to be developed electronic device including, but not limited to, a laptop, a desktop computer, a mobile device, a handheld device, etc.

Distributed streaming system 120 can be any known, or to be developed, distributed streaming system where various components thereof such as components 122-1, 122-2, 122-3 and 122-4 communicate with one another to provide a streaming service to users in a distributed fashion. Hereinafter, components 122-1, 122-2, 122-3 and 122-4 may simply be referred to as components 122 or nodes 122. While throughout the present disclosure, distributed streaming system is provided as an example, the present disclosure is not limited thereto and can encompass and be applicable to any distributed systems that can be abstracted into a Directed Acyclic Graph (DAG) where each vertex can denote an information/message, and information/messages are passed through edges in certain directions. Other examples of distributed systems include a distributed sensor network where signals are propagated from sensor to sensor, a multi-component data processing system where each component receives and processes chunks of data and pass it to the next component(s).

Each one of components 122 can be any know or to be developed electronic device capable of communicating remotely with other devices such as other components 122. For example, each component 122 can be a mobile device, a laptop, a desktop computer, a switch, a data center comprising one or more servers, etc. For example, while some of components 122 can be end user devices or hosts, other ones of components 122 can be servers that facilitate the streaming services provided by distributed streaming system 120.

Furthermore, distributed streaming system 120 can have a server 114 acting as a collector of information (data) for other components (end user devices) in the system. Examples of data include device metrics such as device ID, an associated timestamp, device IP address, device throughput, device latency, memory and processing speed characteristics, etc.

In one example, system 100 further includes one or more feedback servers 116, where various types of data (to be used by controller 102) on components 122 can be collected and saved. In another example, system 100 does not include any feedback servers and instead can directly receive (through push or pull operations) the intended data (which will be described below) from each component 122.

Distributed streaming system 120 can be a cloud based system, where each component thereof is located in a different geographical location but can communicate with one another to form distributed streaming system 120 (e.g., over the Internet).

Examples of streaming services provided via distributed streaming system 120 can include, but is not limited to, live video and/or audio content such as a speech, a concert, a TV program, music, etc.

Operations of distributed streaming system 120 for delivering a streaming service to end users can be based on any know or to be developed method for doing so, by for example, continuously processing a stream of text, graphs, videos, audios, time series data, etc. in real time or near real time or periodically. The system 100 of FIG. 1A utilizes client/server based architectures. In other examples, system 100 can be implemented as a cloud or fog computing architecture.

FIG. 1B illustrates a diagram of an example cloud computing architecture 130. The architecture can include a cloud 132. The cloud 132 can include one or more private clouds, public clouds, and/or hybrid clouds. Moreover, the cloud 132 can include cloud elements 134-144. The cloud elements 134-144 can include, for example, servers 134, virtual machines (VMs) 136, one or more software platforms 138, applications or services 140, software containers 142, and infrastructure nodes 144. The infrastructure nodes 144 can include various types of nodes, such as compute nodes, storage nodes, network nodes, management systems, etc. In one example, one or more servers 134 can implement the functionalities of controller 102, which will be described below. Alternatively, controller 102 can be a separate component that communicates with components of the cloud computing architecture 130 that function as a distributed streaming system similar to the distributed streamlining system 120.

The cloud 132 can provide various cloud computing services via the cloud elements 134-144, such as software as a service (SaaS) (e.g., collaboration services, email services, enterprise resource planning services, content services, communication services, etc.), infrastructure as a service (IaaS) (e.g., security services, networking services, systems management services, etc.), platform as a service (PaaS) (e.g., web services, streaming services, application development services, etc.), function as a service (FaaS), and other types of services such as desktop as a service (DaaS), information technology management as a service (ITaaS), managed software as a service (MSaaS), mobile backend as a service (MBaaS), etc.

The client endpoints 146 can connect with the cloud 132 to obtain one or more specific services from the cloud 132. The client endpoints 146 can communicate with elements 134-144 via one or more public networks (e.g., Internet), private networks, and/or hybrid networks (e.g., virtual private network). The client endpoints 146 can include any device with networking capabilities, such as a laptop computer, a tablet computer, a server, a desktop computer, a smartphone, a network device (e.g., an access point, a router, a switch, etc.), a smart television, a smart car, a sensor, a GPS device, a game system, a smart wearable object (e.g., smartwatch, etc.), a consumer object (e.g., Internet refrigerator, smart lighting system, etc.), a city or transportation system (e.g., traffic control, toll collection system, etc.), an internet of things (IoT) device, a camera, a network printer, a transportation system (e.g., airplane, train, motorcycle, boat, etc.), or any smart or connected object (e.g., smart home, smart building, smart retail, smart glasses, etc.), and so forth.

FIG. 1C illustrates a diagram of an example fog computing architecture 150. The fog computing architecture 150 can include the cloud layer 154, which includes the cloud 132 and any other cloud system or environment, and the fog layer 156, which includes fog nodes 162. The client endpoints 146 can communicate with the cloud layer 154 and/or the fog layer 156. The architecture 150 can include one or more communication links 152 between the cloud layer 154, the fog layer 156, and the client endpoints 146. Communications can flow up to the cloud layer 154 and/or down to the client endpoints 146.

In one example, one or more servers 134 can implement the functionalities of controller 102, which will be described below. Alternatively, controller 102 can be a separate component that communicates with components of the fog computing architecture 150 that function as a distributed streaming system similar to the distributed streamlining system 120

The fog layer 156 or “the fog” provides the computation, storage and networking capabilities of traditional cloud networks, but closer to the endpoints. The fog can thus extend the cloud 132 to be closer to the client endpoints 146. The fog nodes 162 can be the physical implementation of fog networks. Moreover, the fog nodes 162 can provide local or regional services and/or connectivity to the client endpoints 146. As a result, traffic and/or data can be offloaded from the cloud 132 to the fog layer 156 (e.g., via fog nodes 162). The fog layer 156 can thus provide faster services and/or connectivity to the client endpoints 146, with lower latency, as well as other advantages such as security benefits from keeping the data inside the local or regional network(s).

The fog nodes 162 can include any networked computing devices, such as servers, switches, routers, controllers, cameras, access points, kiosks, gateways, etc. Moreover, the fog nodes 162 can be deployed anywhere with a network connection, such as a factory floor, a power pole, alongside a railway track, in a vehicle, on an oil rig, in an airport, on an aircraft, in a shopping center, in a hospital, in a park, in a parking garage, in a library, etc.

In some configurations, one or more fog nodes 162 can be deployed within fog instances 158, 160. The fog instances 158, 158 can be local or regional clouds or networks. For example, the fog instances 156, 158 can be a regional cloud or data center, a local area network, a network of fog nodes 162, etc. In some configurations, one or more fog nodes 162 can be deployed within a network, or as standalone or individual nodes, for example. Moreover, one or more of the fog nodes 162 can be interconnected with each other via links 164 in various topologies, including star, ring, mesh or hierarchical arrangements, for example.

In some cases, one or more fog nodes 162 can be mobile fog nodes. The mobile fog nodes can move to different geographic locations, logical locations or networks, and/or fog instances while maintaining connectivity with the cloud layer 154 and/or the endpoints 146. For example, a particular fog node can be placed in a vehicle, such as an aircraft or train, which can travel from one geographic location and/or logical location to a different geographic location and/or logical location. In this example, the particular fog node may connect to a particular physical and/or logical connection point with the cloud 154 while located at the starting location and switch to a different physical and/or logical connection point with the cloud 154 while located at the destination location. The particular fog node can thus move within particular clouds and/or fog instances and, therefore, serve endpoints from different locations at different times.

FIG. 1D illustrates a schematic block diagram of an example network architecture 180. In some cases, the architecture 180 can include a data center, which can support and/or host the cloud 132. Moreover, the architecture 180 includes a network fabric 182 with spines 184A, 18413, . . . , 184N (collectively “184”) connected to leafs 186A, 186B, 186C, . . . , 186N (collectively “186”) in the network fabric 182. Spines 184 and leafs 186 can be Layer 2 and/or Layer 3 devices, such as switches or routers. For the sake of clarity, they will be referenced herein as spine switches 184 and leaf switches 186.

Spine switches 184 connect to leaf switches 186 in the fabric 182. Leaf switches 186 can include access ports (or non-fabric ports) and fabric ports. Fabric ports can provide uplinks to the spine switches 182, while access ports can provide connectivity for devices, hosts, endpoints. VMs, or external networks to the fabric 182.

Leaf switches 186 can reside at the boundary between the fabric 182 and the tenant or customer space. The leaf switches 186 can route and/or bridge the tenant packets and apply network policies. In some cases, a leaf switch can perform one or more additional functions, such as implementing a mapping cache, sending packets to the proxy function when there is a miss in the cache, encapsulate packets, enforce ingress or egress policies, etc.

Moreover, the leaf switches 186 can contain virtual switching and/or tunneling functionalities, such as a virtual tunnel endpoint (VTEP) function. Thus, leaf switches 186 can connect the fabric 182 to an overlay (e.g., VXLAN network).

Network connectivity in the fabric 182 can flow through the leaf switches 186. The leaf switches 186 can provide servers, resources, endpoints, external networks, containers, or VMs access to the fabric 182, and can connect the leaf switches 186 to each other. The leaf switches 186 can connect applications and/or endpoint groups (“EPGs”) to other resources inside or outside of the fabric 182 as well as any external networks.

Endpoints 192A-D (collectively “192”) can connect to the fabric 182 via leaf switches 186. For example, endpoints 192A and 192B can connect directly to leaf switch 186A, which can connect endpoints 192A and 192B to the fabric 182 and/or any other of the leaf switches 186. Similarly, controller 102 (which can be the same as controller 102 described above with reference to FIG. 1A) can connect directly to leaf switch 186C, which can connect controller 102 to the fabric 182 and/or any other of the leaf switches 186. On the other hand, endpoints 192C and 192D can connect to leaf switch 186A and 186B via network 188. Moreover, the wide area network (WAN) 190 can connect to the leaf switches 186N.

Endpoints 192 can include any communication device or resource, such as a computer, a server, a cluster, a switch, a container, a VM, a virtual application, etc. In some cases, the endpoints 192 can include a server or switch configured with a virtual tunnel endpoint functionality which connects an overlay network with the fabric 182. For example, in some cases, the endpoints 192 can represent hosts (e.g., servers) with virtual tunnel endpoint capabilities, and running virtual environments (e.g., hypervisor, virtual machine(s), containers, etc.). An overlay network associated with the endpoints 192 can host physical devices, such as servers; applications; EPGs; virtual segments; virtual workloads; etc. Likewise, endpoints 192 can also host virtual workloads and applications, which can connect with the fabric 182 or any other device or network, including an external network.

The disclosure now turns to FIGS. 2 and 3, which illustrate example network devices and computing devices, such as switches, routers, load balancers, client devices, and so forth.

FIG. 2 illustrates an example network device suitable for performing switching, routing, load balancing, and other networking operations, according to an aspect of the present disclosure. In one example, network device 200 can be controller 102 and/or any one of components 122 of FIG. 1A. Network device 200 includes a central processing unit (CPU) 204, interfaces 202, and a bus 210 (e.g., a PCI bus). When acting under the control of appropriate software or firmware. CPU 204 is responsible for executing packet management, error detection, and/or routing functions. CPU 204 preferably accomplishes all these functions under the control of software including an operating system and any appropriate applications software. CPU 204 may include one or more processors 208, such as a processor from the INTEL X86 family of microprocessors. In some cases, processor 208 can be specially designed hardware for controlling the operations of network device 200. In some cases, a memory 206 i (e.g., non-volatile RAM. ROM, etc.) also forms part of CPU 204. However, there are many different ways in which memory could be coupled to the system.

Interfaces 202 are typically provided as modular interface cards (sometimes referred to as “line cards”). Generally, they control the sending and receiving of data packets over the network and sometimes support other peripherals used with network device 200. Among the interfaces that may be provided are Ethernet interfaces, frame relay interfaces, cable interfaces, DSL interfaces, token ring interfaces, and the like. In addition, various very high-speed interfaces may be provided such as fast token ring interfaces, wireless interfaces. Ethernet interfaces. Gigabit Ethernet interfaces, ATM interfaces, HSSI interfaces, POS interfaces, FDDI interfaces, WIFI interfaces, 3G/4G/5G cellular interfaces, CAN BUS, LoRA, and the like. Generally, these interfaces may include ports appropriate for communication with the appropriate media. In some cases, they may also include an independent processor and, in some instances, volatile RAM. The independent processors may control such communications intensive tasks as packet switching, media control, signal processing, crypto processing, and management. By providing separate processors for the communications intensive tasks, these interfaces allow the master microprocessor 204 to efficiently perform routing computations, network diagnostics, security functions, etc.

Although the system shown in FIG. 2 is one specific network device of the present invention, it is by no means the only network device architecture on which the present invention can be implemented. For example, an architecture having a single processor that handles communications as well as routing computations, etc., is often used. Further, other types of interfaces and media could also be used with network device 200.

Regardless of the network device's configuration, it may employ one or more memories or memory modules (including memory 206) configured to store program instructions for the general-purpose network operations and mechanisms for roaming, route optimization and routing functions described herein. The program instructions may control the operation of an operating system and/or one or more applications, for example. The memory or memories may also be configured to store tables such as mobility binding, registration, and association tables, etc. Memory 206 could also hold various software containers and virtualized execution environments and data.

Network device 200 can also include an application-specific integrated circuit (ASIC), which can be configured to perform routing and/or switching operations. The ASIC can communicate with other components in network device 200 via bus 210, to exchange data and signals and coordinate various types of operations by network device 200, such as routing, switching, and/or data storage operations, for example.

FIG. 3 illustrates a computing system architecture, according to an aspect of the present disclosure. As shown in FIG. 3, components of system 300 are in electrical communication with each other using a connection 305, such as a bus. Exemplary system 300 includes a processing unit (CPU or processor) 310 and a system connection 305 that couples various system components including system memory 315, such as read only memory (ROM) 320 and random access memory (RAM) 325, to processor 710. System 300 can include a cache of high-speed memory connected directly with, in close proximity to, or integrated as part of the processor 310. System 300 can copy data from memory 315 and/or storage device 330 to cache 312 for quick access by processor 310. In this way, the cache can provide a performance boost that avoids processor 310 delays while waiting for data. These and other modules can control or be configured to control the processor 310 to perform various actions. Other system memory 315 may be available for use as well. Memory 315 can include multiple different types of memory with different performance characteristics. Processor 310 can include any general purpose processor and a hardware or software service, such as Service 1 332, Service 2 334, and Service 3 336 stored in storage device 330, configured to control processor 310 as well as a special-purpose processor where software instructions are incorporated into the actual processor design. Processor 310 may be a completely self-contained computing system, containing multiple cores or processors, a bus, memory controller, cache, etc. A multi-core processor may be symmetric or asymmetric.

To enable user interaction with the computing device 300, an input device 345 can represent any number of input mechanisms, such as a microphone for speech, a touch-sensitive screen for gesture or graphical input, keyboard, mouse, motion input, speech and so forth. An output device 335 can also be one or more of a number of output mechanisms known to those of skill in the art. In some instances, multimodal systems can enable a user to provide multiple types of input to communicate with computing device 300. The communications interface 340 can generally govern and manage the user input and system output. There is no restriction on operating on any particular hardware arrangement and therefore the basic features here may easily be substituted for improved hardware or firmware arrangements as they are developed.

Storage device 330 is a non-volatile memory and can be a hard disk or other types of computer readable media which can store data that are accessible by a computer, such as magnetic cassettes, flash memory cards, solid state memory devices, digital versatile disks, cartridges, random access memories (RAMs) 325, read only memory (ROM) 320, and hybrids thereof.

The storage device 330 can include services 332, 334, 336 for controlling the processor 310. Other hardware or software modules are contemplated. The storage device 330 can be connected to the system connection 305. In one aspect, a hardware module that performs a particular function can include the software component stored in a computer-readable medium in connection with the necessary hardware components, such as the processor 310, connection 305, output device 335, and so forth, to carry out the function.

FIG. 4 illustrates an example system of containers providing a service, according to an aspect of the present disclosure.

According to FIG. 4, a physical host 400 (which can be any one of servers 134, VMs 136, Software platforms 138, Applications 140, containers 142 and/or infrastructure nodes 144 shown in FIG. 1B) has a physical port 402, through which real time network traffic (e.g., data packets) arrive at the physical host 400, via cloud 132, to be processed. Physical host 400 can have Contiv HostAgent 404, Contiv HostAgent 404 (hereinafter Contiv 404) is implemented via one or more processors of physical host 400 for delivering/deploying micro-services on physical host 400. As is known, Contiv 404 is a network abstraction layer for microservices, with examples of microservices being service functions (SF) (which can also be referred to as Containers) 406, 408, 410 and 412.

Contiv 404, as shown in FIG. 4, can have one or more virtual input/output ports to and from containers 406-412, such as vport1 to container 406, vport11 to container 408, vport12 to container 410 and vport13 to container 412. Each of containers 406-412 can have an associated virtual port (eth0) for exchange of network traffic (data packets) with Contiv 404 via corresponding vport of Contiv 404. In one non-limiting example of containers 406-412, as shown in FIG. 4, container 406 is a service function forwarder (SFF) that implements policies for forwarding/load balancing network traffic between containers that provide a particular service function. In another example, there is no SFF/container 406 but instead Contiv 404 performs the functionalities of SFF/container 406. Furthermore and according to the same non-limiting example, containers 408 and 410 can be production containers that provide one or more service functions such as a firewall service. Therefore, containers 408 and 410 can be considered to form a firewall cluster. Lastly and according to the same non-limiting example, container 412 is a non-production container (e.g., a container in a test mode that is to be validated before being moved to production as part of the firewall cluster). Examples of the present disclosure, as will be described below, enable the use of the real time network traffic received at physical port 402 in order to test/validate policies/functionality/performance of non-production container 412.

While FIG. 4 illustrates a particular number of containers of various type or functionality (e.g., SFF, production containers, non-production container, etc.), inventive concepts are not limited thereto. Furthermore, while not shown in FIG. 4, each and every container that is part of the same service function (e.g., the firewall cluster example mentioned above) need not be hosted on the same physical host 400 but can span two or more physical hosts that can be located in different geographical locations.

Hereinafter, a process of using real time network traffic for validating the performance of containers in test mode (non-production mode) will be described.

FIG. 5 describes a method of replicating real time network traffic for validating a container performance, according to an aspect of the present disclosure. FIG. 5 is described with reference to FIG. 4 and is from the perspective of Contiv 404 of FIG. 4. However, it will be understood that one or more processors that execute computer-readable instructions to function as Contiv 404 perform the process of FIG. 5.

At S500, Contiv 404 (which can also be referred to as Controller 404) receives real time network traffic at physical port 402 via cloud 132. As is known, the real time network traffic arrives as one or more data packets (incoming data packets) at physical port 402.

At S501, Contiv 404 performs load balancing between production containers (e.g., containers 408 and 410 of FIG. 4) for servicing the incoming data packet (e.g., providing the firewall service described above with reference to FIG. 4).

At S502, Contiv 404 determines if an incoming data packet is to be replicated. In one example, Contiv 404 determines that the incoming data packet is to be replicated by accessing a table stored in a memory associated with Contiv 404 that identifies non-production containers that need to be validated/tested. An example of such table is shown in FIG. 6. Table 600 shown in FIG. 6 is a table that identifies details of each container instantiated on physical host 400. Table 600 can be referred to as a Contiv service module/database and, as shown, includes details of each container including, but not limited to, each container's micro-service type (e.g., cluster ID. IP address. Port, etc.), as well as additional details such as whether the container is under test (in non-production) mode or is in production. It can also be seen from Table 600 that Contiv Service Module includes entries for each container indicating whether validation thereof is required. In the example of FIG. 6, Table 600 indicates that container 412 (SF3) requires validation and that it is in non-production mode (identified under the Segment column). Therefore, at S502 and based on Table 600, Contiv 404 determines that the incoming data packet(s) need to be replicated for validating performance of non-production container 412. Moreover, Table 600 shows which incoming network traffic (data packets) are to be replicated. For example, under the column titled “replication required”, it is shown that the incoming data packets destined for container 408 at vport11 are to be replicated.

If at S502, Contiv 404 determines that no container in Table 600 is identified as being in the non-production mode that needs validation, the process reverts back to S500.

After determining that the incoming data packet is to be replicated at S502, at S504, Contiv 404 replicates the incoming data packet, which in the example of Table 600 would be the incoming data packet destined for container 408 at vport11.

In one example and as part of replicating the incoming data packets, Contiv 404 marks a header (a network service header, a SRv6 header, a new IPv6 header, etc.) of the replicated data packet with a test flag (e.g., sets a parameter of the header to 1).

Thereafter, at S506, Contiv 404 sends the replicated data packet for which the test flag has been marked to the non-production container (e.g., container 412 of FIG. 4), via vport13. In one example, when the non-production container is not hosted on the same physical host 400 on which Contiv 404 is running, Contiv 404 formulates an overlay (e.g., VXLAN) for forwarding the replicated and marked data packet to the physical host on which the non-production container is hosted and instantiated.

At S508, Contiv 404 receives data packets back from containers, including non-production container(s) such as container 412, at corresponding vports as shown in FIG. 4.

At S510, Contiv 404 checks the received data packets to determine if the header thereof indicates that the received data packet is a test data packet for container validation (e.g., if a network service header bit, a SRv6 header bit, a new IPv6 header bit, etc. is set to 1).

If at S510, Contiv 404 determines that the received data packet is not a test data packet. Contiv 404 processes the received data packet normally at S511 (e.g., forwards the received data packet to physical port 402 to be sent back via cloud 132 to the intended destination and/or forwards the data packet to other containers/VMs/etc. for further processing).

However, if at S510, Contiv 404 determines that the received data packet is a test data packet, then at S512, Contiv 404 stores the data packet received (e.g., in a memory associated with Contiv 404).

Thereafter, at 8514, Contiv 404 drops the data packet received at S508.

At S516, Contiv 404 determines if testing of non-production container is to be continued, which indicates that more real time incoming data packets need to be replicated. This determination can be based on a designated amount of time according to which a particular non-production container is to be tested before a final determination is made for moving the same to production. This may be a user-specified and configurable time period.

If at S516, Contiv 404 determines that more testing is to be performed, the process reverts back to S500 and Contiv 404 repeats S500 to S514. However, if at S516, Contiv 404 determines that no more testing is required, then at S518, Contiv 404 analyzes the received data packets stored at S512 to determine if the non-production container's performance can be validated. In one example, Contiv 404 determines if the received data packets are within an expected service level agreement (SLA). If the received data packets are within the expected SLA, Contiv 404 determines that the non-production container 412 should be brought into production (e.g., as part of the firewall cluster example together with containers 408 and 410 of FIG. 4).

Thereafter, at S520, Contiv 404 updates its policies (e.g., forwarding rules) such that replication of incoming data packets is stopped and any new incoming data packets are also sent to container 412 that provide the particular service function (firewall service) along with containers 408 and 410. The forwarding of incoming data packets to containers 408-412 can be based on any underlying load balancing to be performed by Contiv 404 among available production containers.

In examples described above with reference to FIG. 5, Contiv 404 operates as a SFF. However, in another example, Contiv 404 may not operate as a SFF and instead container 406 of FIG. 4 is a SFF. Accordingly, upon receiving an incoming data packet at S500, Contiv 404 sends the received incoming data packet to container 406, where container 406 performs load balancing of S501 as well as processes of replicating and marking the incoming data packet at S502 and S504. The replicated and marked incoming data packet is then sent back to Contiv 404 to be forwarded to the non-production container in the same manner as described above with reference to S506. Thereafter, Contiv 404 performs S508 to S520, as described above.

FIG. 7 illustrates an example of the container validation process of FIG. 5, according an aspect of the present disclosure.

As shown in FIG. 7, Contiv 404 operates as a SFF and thus, relative to FIG. 4, container 406 is not included. Furthermore, physical host 400, Contiv 404, containers 408, 410 and 412 are the same as those described above with reference to FIG. 4.

As in S500, an incoming data packet is received at physical port 402 via cloud 132. The incoming data packet has a format 700 including a payload 702, a network service header (NSH) 704 and an IP header 706.

As in S501, Contiv 404 sends the incoming data packet 700 to container 408 for processing via vport11. Upon determining that the incoming data packet 700 is to be replicated for testing non-production container 412, as described above with reference to S502, Contiv 404 replicates incoming data packet 700 to generate a replicated data packet 710 and also marks the replicated data packet with test flag in the NSH header (or alternatively SRv6, or IPv6 header) thereof. Accordingly, as shown in FIG. 7, the replicated data packet 710 has the same payload 702 and IP header 706 but instead has a revised NSH header (or alternatively SRv6, or IPv6 header) 712 in which a test flag is set to 1 indicating that the data packet is replicated for testing non-production container 412. Contiv 404 then sends the replicated and marked data packet 710 to non-production container 412 via corresponding vport13, as described with reference to S506 of FIG. 5.

While not illustrated in FIG. 7, upon receiving the replicated data packet 710 back from container 412, Contiv 404 performs S508-S520, as described above with reference to FIG. 5.

FIG. 8 illustrates an example of the container validation process of FIG. 5, according an aspect of the present disclosure.

As shown in FIG. 8, physical host 400 has a SFF shown as container 404 (as described above with reference to FIG. 4). Accordingly, Contiv 404 does not operate as a SFF. Furthermore, physical host 400, Contiv 404, containers 408, 410 and 412 are the same as those described above with reference to FIG. 4.

Incoming data packet 700 is the same as that described above with reference to FIG. 7. First, incoming data packet 700 is received at physical port 402 via cloud 132, Contiv 404 forwards the incoming data packet 700 to container 406 that functions as a SFF. Container 406, after performing load balancing, can send the incoming data packet 700 to container 406 for processing.

Upon determining that container 412 is in non-production mode for testing, per S502 described above, container 406 replicates and marks the incoming data packet 700 in the same manner as described above with reference to FIG. 5 and FIG. 7 (generates replicated data packet 710). Thereafter, Contiv 404 sends the replicated data packet 710 to container 412 for testing. Furthermore and as shown in FIG. 8, Contiv 404 receives the replicated data packet 710 back from container 412, at which point Contiv 404 drops the replicated data packet 710 because Contiv 404 detects the test flag in the NSH header (or alternatively SRv6, or IPv6 header) 712 being set to 1.

While not illustrated in FIG. 8, upon receiving the replicated data packet 710 back from container 412 and dropping the same, Contiv 404 performs S510-S520, as described above with reference to FIG. 5.

For clarity of explanation, in some instances the present technology may be presented as including individual functional blocks including functional blocks comprising devices, device components, steps or routines in a method embodied in software, or combinations of hardware and software.

In some embodiments the computer-readable storage devices, mediums, and memories can include a cable or wireless signal containing a bit stream and the like. However, when mentioned, non-transitory computer-readable storage media expressly exclude media such as energy, carrier signals, electromagnetic waves, and signals per se.

Methods according to the above-described examples can be implemented using computer-executable instructions that are stored or otherwise available from computer readable media. Such instructions can comprise, for example, instructions and data which cause or otherwise configure a general purpose computer, special purpose computer, or special purpose processing device to perform a certain function or group of functions. Portions of computer resources used can be accessible over a network. The computer executable instructions may be, for example, binaries, intermediate format instructions such as assembly language, firmware, or source code. Examples of computer-readable media that may be used to store instructions, information used, and/or information created during methods according to described examples include magnetic or optical disks, flash memory, USB devices provided with non-volatile memory, networked storage devices, and so on.

Devices implementing methods according to these disclosures can comprise hardware, firmware and/or software, and can take any of a variety of form factors. Typical examples of such form factors include laptops, smart phones, small form factor personal computers, personal digital assistants, rackmount devices, standalone devices, and so on. Functionality described herein also can be embodied in peripherals or add-in cards. Such functionality can also be implemented on a circuit board among different chips or different processes executing in a single device, by way of further example.

The instructions, media for conveying such instructions, computing resources for executing them, and other structures for supporting such computing resources are means for providing the functions described in these disclosures.

Although a variety of examples and other information was used to explain aspects within the scope of the appended claims, no limitation of the claims should be implied based on particular features or arrangements in such examples, as one of ordinary skill would be able to use these examples to derive a wide variety of implementations. Further and although some subject matter may have been described in language specific to examples of structural features and/or method steps, it is to be understood that the subject matter defined in the appended claims is not necessarily limited to these described features or acts. For example, such functionality can be distributed differently or performed in components other than those identified herein. Rather, the described features and steps are disclosed as examples of components of systems and methods within the scope of the appended claims.

Claim language reciting “at least one of” refers to at least one of a set and indicates that one member of the set or multiple members of the set satisfy the claim. For example, claim language reciting “at least one of A and B” means A. B, or A and B. 

What is claimed is:
 1. A method comprising: receiving, at a controller, an incoming data packet destined for one or more containers; determining, at the controller, the incoming data packet is to be replicated by accessing a table stored in a memory of the controller; replicating, at the controller, the incoming data packet for validating at least one non-production container to yield a replicated data packet; sending the replicated data packet to the at least one non-production container; receiving a received data packet from the at least one non-production container at a corresponding incoming port of the controller; checking the received data packet to determine whether the received data packet is a test data packet; when the received data packet is determined not to be the test data packet, forwarding the received data packet; when the received data packet is determined to be the test data packet, storing the received data packet in the memory of the controller and dropping the received data packet after the received data packet has been stored in the memory of the controller; and when the received data packet is within a service level agreement (SLA), converting the at least one non-production container to a production container via a policies update so the replicating of the incoming data packets for the validating of the at least one non-production container is stopped and the at least one non-production container can receive incoming packets.
 2. The method of claim 1, wherein the table is a service module table that identifies production and non-production containers of a service identified as a destination of the incoming data packet.
 3. The method of claim 2, wherein the determining that the incoming data packet is to be replicated is based on a determination that the service module table identifies the one or more containers and the non-production container as being associated with the service.
 4. The method of claim 1, wherein the replicating of the incoming data packet includes setting a test flag in a header of the replicated data packet.
 5. The method of claim 4, wherein the checking of the received data packet to determine if the received data packet is the test data packet includes determining the received data packet includes the test flag.
 6. The method of claim 1, further comprising: performing load balancing between the one or more containers; and transmitting the incoming data packet to the one or more containers based on the load balancing.
 7. The method of claim 1, further comprising: determining whether the at least one non-production container is hosted on a same physical host as the controller; and transmitting the replicated data packet to an Internet Protocol (IP) address associated with a physical host on which the at least one non-production container is hosted when the at least one non-production container is determined to not be hosted on the same physical host.
 8. A device comprising: a memory having computer-readable instructions stored therein; and one or more processors configured to execute the computer-readable instructions to: receive an incoming data packet destined for one or more containers; determine the incoming data packet is to be replicated by accessing a table stored in the memory; replicate the incoming data packet for validating at least one non-production container to yield a replicated data packet; send the replicated data packet to the at least one non-production container; receive a received data packet from the at least one non-production container at a corresponding incoming port of a controller; check the received data packet to determine whether the received data packet is a test data packet; when the received data packet is determined not to be the test data packet, forward the received data packet; and when the received data packet is determined to be the test data packet, store the received data packet in the memory and drop the received data packet after the received data packet has been stored in the memory; and when the received data packet is within a service level agreement (SLA), convert the at least one non-production container to a production container via a policies update so the replicating of the incoming data packets for the validating of the at least one non-production container is stopped and the at least one non-production container can receive incoming packets.
 9. The device of claim 8, wherein, the device is a physical host, and the one or more processors are configured to operate as a Contiv host agent for directing the incoming data packet to the one or more containers.
 10. The device of claim 9, wherein, the computer-readable instructions include instructions for implementing a container as a service function forwarder, the one or more processors are further configured to implement the service function forwarder, and the Contiv host agent is configured to direct the incoming data packet to the service function forwarder for performing replication of the incoming data packet, send the replicated data packet to the at least one non-production container, and drop any data packet received from the at least one non-production container, if the replication is required.
 11. The device of claim 8, wherein the table is a service module table that identifies production and non-production containers of a service identified as a destination of the incoming data packet.
 12. The device of claim 11, wherein determining the incoming data packet is to be replicated is based on a determination that the service module table identifies the one or more containers and the non-production container as being associated with the service.
 13. The device of claim 8, wherein the one or more processors are further configured to execute the computer-readable instructions to replicate the incoming data packet by setting a test flag in a header of the replicated data packet.
 14. The device of claim 13, wherein the one or more processors are further configured to execute the computer-readable instructions to drop any received data packet from the at least one non-production container if the received data packet has the test flag.
 15. The device of claim 8, wherein, the one or more processors are further configured to execute the computer-readable instructions to: perform load balancing between the one or more containers; and transmit the incoming data packet to the one or more containers based on the load balancing.
 16. The device of claim 8, wherein, the one or more processors are further configured to execute the computer-readable instructions to: determine whether the at least one non-production container is hosted on a same physical host as the controller; and upon determining that the at least one non-production container is not hosted on the same physical host as the controller, transmit the replicated data packet to an Internet Protocol (IP) address associated with a physical host on which the at least one non-production container is hosted.
 17. One or more non-transitory computer-readable mediums having computer-readable instructions stored thereon, which when executed by one or more processors, cause the one or more processors to: receive an incoming data packet destined for one or more containers; determine the incoming data packet is to be replicated by accessing a table stored in a memory; replicate the incoming data packet for validating at least one non-production container to yield a replicated data packet; send the replicated data packet to the at least one non-production container; receive a received data packet from the at least one non-production container; check the received data packet to determine whether the received data packet is a test data packet; when the received data packet is determined not to be the test data packet, forward the received data packet; when the received data packet is determined to be the test data packet, store the received data packet in the memory and drop the received data packet after the received data packet has been stored in the memory; and when the received data packet is within a service level agreement (SLA), convert the at least one non-production container to a production container via a policies update so the replicating of the incoming data packets for the validating of the at least one non-production container is stopped and the at least one non-production container can receive incoming packets.
 18. The one or more non-transitory computer-readable medium of claim 17, wherein the table is a service module table that identifies production and non-production containers of a service identified as a destination of the incoming data packet.
 19. The one or more non-transitory computer-readable medium of claim 17, wherein, execution of the computer-readable instructions further causes the one or more processors to: replicate the incoming data packet by setting a test flag in a header of the replicated data packet; and drop any received data packet if the received data packet has the test flag.
 20. The one or more non-transitory computer-readable medium of claim 17, wherein, execution of the computer-readable instructions further causes the one or more processors to: perform load balancing between the one or more containers; and transmit the incoming data packet to the one or more containers based on the load balancing. 